maxerbox / fisherman-discord.js

/**

 * A register, to add commands to fisherman extending the Map class

 * The commands added are storen directly in the map

 * @class FisherRegister

 * @extends {Map}

 */

class FisherRegister extends Map {

    /**

     * Creates an instance of FisherRegister.

     * @param {Fisherman} client

     * @memberof FisherRegister

     */

     * A text command that can be only executed in a guild

     * @example textCommand("cat", null, function(req,res) {});

     * @param {string} name The command's name

     * @param {FisherCallback} callback A FisherCallback

     * @return {FisherRegister} Return the current register

     */

  textCommand (name, options, callback) {

    if (typeof callback !== 'function') { throw new TypeError('Callback must be a function') }

    if (typeof name !== 'string') {

      throw new TypeError('Command name must be a string')

    }

    var cmd = Object.create(defaultCommandOptions)

    cmd.register = this

    cmd.channelType = 'text'

    cmd.execute = callback.bind(cmd)

    cmd.name = name

    cmd = Object.assign(cmd, options)

    this.set(name, cmd)

    return this

  }

    /**

     * A command, specified by the name and the scope.

     * @example command(["dm", "text"], "cat", null, function(req, res){});

     * @param {(string[]|string)} scope The channel type, can be an array or a string

     * @param {string} name The command's name

     * @param {FisherCallback} callback A FisherCallback

     * @return {FisherRegister} Return the current register

     * @memberof FisherRegister

     */

    if (!Array.isArray(scope) || !(typeof scope === 'string')) { throw new TypeError('scope must be a string or an array') }

    if (typeof callback !== 'function' || typeof name !== 'string') { throw new TypeError('Callback must be a function, command name must be a string') }

    var cmd = Object.create(defaultCommandOptions)

    cmd.register = this

    cmd.channelType = scope

    cmd.execute = callback.bind(cmd)

    cmd.name = name

    cmd = Object.assign(cmd, options)

    this.set(name, cmd)

    return this

  }

  /**

   * A command, that can be resolved/rejected. It triggers fishercodes when it's resolved/rejected

   * @example command(["dm", "text"], "cat", null, function(req, res, resolve, reject){});

   * @param {(string[]|string)} scope The channel type, can be an array or a string

   * @param {string} name The command's name

   * @param {FisherPromiseCallback} callback A FisherPromiseCallback

   * @return {FisherRegister} Return the current register

   * @memberof FisherRegister

   */

    if (!(Array.isArray(scope) || typeof scope === 'string')) { throw new TypeError('scope must be a string or an array') }

    if (typeof callback !== 'function' || typeof name !== 'string') { throw new TypeError('Callback must be a function, command name must be a string') }

    var cmd = Object.create(defaultCommandOptions)

    cmd.register = this

    cmd.isPromise = true

    cmd.channelType = scope

    cmd.execute = callback.bind(cmd)

    cmd.name = name

    cmd = Object.assign(cmd, options)

    this.set(name, cmd)

    return this

  }

    /**

     * Add a command to fisherman, through an object or an command class extending the abstract class "Command"

     * @param {(Object|Command)} command An object, or a class extending the abstract class "Command"

     * @memberof FisherRegister

     */

  addCommand (command) {

    var cmd = Object.assign(Object.create(defaultCommandOptions), command)

    this.set(cmd.name, cmd)

  }

  set (key, value) {

    /**

     * Emitted when a new command is added

     * @event Fisherman#commandAdded

     * @param {Command}

     */

    super.set(key, value)

    this.client.commands.set(key, value)

    this.client.emit('commandAdded', value)

    this.setAliases(key, value)

  }

    /**

     * set the aliases for the fisher client

     * @private

     * @param {string} key

     * @param {Object} value

     * @memberof FisherRegister

     */

  setAliases (key, value) {

    if (typeof value.aliases === 'string') {

      this.client.aliases.set(value.aliases, value)

      this.client.commands.set(value.aliases, value)

    } else if (Array.isArray(value.aliases)) {

      var i

      for (i in value.aliases) {

        this.client.aliases.set(value.aliases[i], value)

        this.client.commands.set(value.aliases[i], value)

      }

    }

  }

    /**

     * delete the aliases for the given command/key

     * @private

     * @param {string} key

     * @memberof FisherRegister

     */

  clearAliases (key) {

    var cmd = super.get(key)

    if (cmd) {

      if (typeof cmd.aliases === 'string') {

        this.client.aliases.delete(cmd.aliases)

        this.client.commands.delete(cmd.aliases)

      } else if (Array.isArray(cmd.aliases)) {

        var i

        for (i in cmd.aliases) {

          this.client.aliases.delete(cmd.aliases[i])

          this.client.commands.delete(cmd.aliases[i])

        }

      }

    }

  }

  delete (key) {

    this.clearAliases(key)

    super.delete(key)

    this.client.commands.delete(key)

  }

}

module.exports = FisherRegister

/**

 * @typedef {function} FisherCallback The command's execution function

 * @param {FisherRequest} req A request object

 * @param {FisherResponse} res A response object

 */

/**

 * @typedef {function} FisherPromiseCallback The promise command's execution function with a promise callback

 * @param {FisherRequest} req A request object

 * @param {FisherResponse} res A response object

 * @param {function} resolve A promise resolve function

 * @param {function} reject A promise reject function

 */